/*        MatrizRestricciones();
        //MatrizRestricciones(Reglas);
        ~MatrizRestricciones();
        void prohibirEmision(Pais, Pais);
        bool puedeVer(Pais, Pais);
        Arreglo<Pais> puedenVerme(Pais);
        Arreglo<Pais> puedoVer(Pais);
        bool esConsistente(Pais);*/

#include "MatrizRestricciones.h"

MatrizRestricciones::MatrizRestricciones(aed2::Nat n) : mat(n + 1 , n + 1, true){
    //el constructor básico llama al constructor de matriz con una posición más para
    //que los países empiecen desde 1.
}

MatrizRestricciones::~MatrizRestricciones()
{
    //destructor
}

void MatrizRestricciones::prohibirEmision(Pais p1, Pais p2){
    assert(p1 != p2);
    assert(p1 > 0 && p2 > 0);
    mat.definir(p1, p2, false);
}

bool MatrizRestricciones::puedeVer(Pais p1, Pais p2) const{
    //assert(p1 != p2); NO
    assert(p1 > 0 && p2 > 0);
    return mat.obtener(p2, p1);
}

Lista<Pais> MatrizRestricciones::puedenVerme(Pais p) const{
    assert(p > 0);
    return boolALista(mat.fila(p));
}

Lista<Pais> MatrizRestricciones::puedoVer(Pais p) const{
    assert(p > 0);
    return boolALista(mat.columna(p));
}

bool MatrizRestricciones::esConsistente(Pais p1) const{
    assert(p1 > 0);
    bool res = true;
    Lista<Pais> _puedoVer = puedoVer(p1);
    Lista<Pais> _puedenVerme = puedenVerme(p1);
    Lista<Pais>::const_Iterador p2 = _puedoVer.CrearIt();
    Lista<Pais>::const_Iterador p3;
    while (p2.HaySiguiente()){
        p3 = _puedenVerme.CrearIt();
        while (p3.HaySiguiente()){
            if (p1 != p2.Siguiente() && p1 != p3.Siguiente() && p2.Siguiente() != p3.Siguiente())
                res = res && puedeVer(p3.Siguiente(), p2.Siguiente());
            p3.Avanzar();
        }
        p2.Avanzar();
    }
    return res;
}


//A partir de acá no se exportan:
Lista<Pais> MatrizRestricciones::boolALista(Arreglo<bool> a) const{
    Lista<Pais> res;
    Pais i;
    for (i = 1; i < a.Tamanho(); i++){
        if (a[i])
            res.AgregarAtras(i);
    }
    return res;
}
